char IN_STR[128];
unsigned __out __bits(16) RES;

void main()
{
unsigned int cnt = 0;
int i = 0;

while (IN_STR[i] != '#')
{
if (IN_STR[i] == 'A' ||
IN_STR[i] == 'E' ||
IN_STR[i] == 'I' ||
IN_STR[i] == 'O' ||
IN_STR[i] == 'U')
{
cnt = cnt + 1;
}
i = i + 1;
}

RES = cnt;
}


------------------------------------------------------------
---------------------
unsigned __bits(8) mas[5];

unsigned __out __bits(8) srd;


void main(void) {
unsigned __bits(3) min = 0;
unsigned __bits(3) max = 0;
for(unsigned __bits(3) i = 0; i < 5; i++) {
if(mas[min] > mas[i]) min = i;
if(mas[max] > mas[i]) max = i;
}

srd = (mas[min] + mas[max]) / 2;
}


------------------------------------------------------------
---------------------
unsigned __bits(8) mas[5];
unsigned __bits(8) srd;

void main() {
unsigned __bits(3) min;
unsigned __bits(3) max;
min = mas[0];
max = mas[0];
for (unsigned __bits(3) i = 1; i < 5; i++) {
if (mas[i] < min) {
min = mas[i];
}
if (mas[i] > max) {
max = mas[i];
}
}
srd = (min + max) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];

int __out __bits(8) srd;

void main()
{
int mx = 0;
int mn = 0;

int i = 0;

for (i = 0; i < 5; ++i)
{
if (mas[i] > mx)
{
mx = mas[i];
}
if (mas[i] < mn)
{
mn = mas[i];
}
}
srd = (mx + mn) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];

int __out __bits(8) srd;

void main()
{
int mx = -1;
int mn = 0;

int i = 0;

for (i = 0; i < 5; ++i)
{
if (mas[i] > mx)
{
mx = mas[i];
}
if (mas[i] < mn)
{
mn = mas[i];
}
}
srd = (mx + mn) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];

int __out __bits(8) srd;

int main(){

int __bits(8) min = a[0];
int __bits(8) max = a[0];

for(int i = 0; i < 5; i++){
if(min > a[i]){
min = a[i];
}

if(max < a[i]){
max = a[i];
}
}

srd = (min+max) / 2;
}


------------------------------------------------------------
---------------------
unsigned __bits(8)mas[5];

unsigned __out __bits(8)srd;

void main(){
unsigned __bits(8)max=mas[0];
unsigned __bits(8)min=mas[0];
for(int i=0;i<5;i++){
if(mas[i]>max){
max=mas[i];
}
if(mas[i]<min){
min=mas[i];
}
}
srd = max+min;
}


------------------------------------------------------------
---------------------
int __bits(8)mas[5];

int __out __bits(8)srd;

void main(){
int __bits(8)max=mas[0];
int __bits(8)min=mas[0];
for(int i=0;i<5;i++){
if(mas[i]>max){
max=mas[i];
}
if(mas[i]<min){
min=mas[i];
}
}
srd = max+min;
}


------------------------------------------------------------
---------------------
unsigned __bits(8) mas[5];
unsigned __bits(8) srd;

void main() {
unsigned __bits(3) min=0;
unsigned __bits(3) max=0;

for (unsigned __bits(3) i = 1; i < 5; i++) {
if (mas[i] < mas[min]) {
min = i;
}
if (mas[i] > mas[max]) {
max = i;
}
}
srd = (mas[min] + mas[max]) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) x[10];
int __out __bits(8) res;


void main(){
int i;
int sump=0;
int sumo=0;

for (i=0; i<10; i++){
if (x[i]>0) sump=sump+x[i];
if (x[i]<0) sumo=(sumo+x[i])*(-1);
}
y=sump%sumo;
}


------------------------------------------------------------
---------------------
int __bits(1) mas[5];
int __bits(1) min, max;
int __bits(1) srd;

void main() {
min = mas[0];
max = mas[0];
for (int i = 1; i < 5; i++) {
if (mas[i] < min) {
min = mas[i];
}
if (mas[i] > max) {
max = mas[i];
}
}
srd = (min + max) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];
int __bits(8) min, max;
int __bits(16) srd;

void main() {
min = mas[0];
max = mas[0];
for (int i = 1; i < 5; i++) {
if (mas[i] < min) {
min = mas[i];
}
if (mas[i] > max) {
max = mas[i];
}
}
srd = (min + max) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];

int __out __bits(8)srd;

void main(){
int __bits(8)min_el=mas[0];
int __bits(8)max_el=mas[0];

for(int i = 0; i < 5; i++){
if(mas[i]>max_el){
max_el=mas[i];
}
if(mas[i]<min_el){
min_el=mas[i];
}
}
srd = (min_el + max_el)/2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];
int __bits(8) srd;
void main(){
unsigned __bits(8) min;
unsigned __bits(8) max;
int i;
for(i=0; i<5 ;i++){
if(min>i)
min = i;
if(max<i)
max = i;
}
srd = (min+max) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];

int __out __bits(1) srd;

void main() {
int __bits(8) max = 0;
int __bits(8) min = mas[0];

for (int i = 0; i < 5; i++) {
if (min > mas[i])
min = mas[i];

if (max < mas[i])
max = mas[i];
}

srd = (max + min) / 2;
}


------------------------------------------------------------
---------------------
int __in __bits(16) mas[5];
int __out __bits(16) srd;

int abs_val(int x) {
return (x < 0) ? -x : x;
}

int sign(int x) {
if (x > 0) return 1;
if (x < 0) return -1;
return 0;
}

void main() {
int min_mas = mas[0];
int max_mas = mas[0];

for (int i = 1; i < 5; i++) {
if (mas[i] < min_mas) {
min_mas = mas[i];
}
if (mas[i] > max_mas) {
max_mas = mas[i];
}
}

srd = (min_mas + max_mas) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) x[10];
unsigned __bits(8) res;

void main()
{
int sum1 = 0;
int sum2 = 0;
int rev;

for (int i = 0; i < 10; i++)
{
if (x[i] > 0)
{
sum1 = sum1 + x[i];
}
else if (x[i] < 0)
{
rev = ~x[i];
sum2 = sum2 + rev;
}
}
res = sum1 % sum2;
}


------------------------------------------------------------
---------------------
unsigned __bits(1) mas[5];

unsigned __out __bits(1) srd;

void main() {
int max = 0;
int min = mas[0];

for (int i = 0; i < 5; i++) {
if (min > mas[i])
min = mas[i];

if (max < mas[i])
max = mas[i];
}

srd = (max + min) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];
int __bits(16) srd;

int __bits(8) min_val;
int __bits(8) max_val;


void main()
{
max_val = mas[0];
min_val = mas[0];

for (int i=1; i<5; i++) {
if (mas[i] < min_val){
min_val = mas[i];
}
if (mas[i] > max_val){
max_val = mas[i];
}
}
srd = (min_val + max_val)/2;
}


------------------------------------------------------------
---------------------
int __bits(8) mas[5];
int __bits(8) min, max;
int __bits(16) srd;

void main() {
min = mas[0];
max = mas[0];
for (int i = 1; i < 5; i++) {
if (mas[i] < min) {
min = mas[i];
}
if (mas[i] > max) {
max = mas[i];
}
}
srd = (min + max) / 2;
}


------------------------------------------------------------
---------------------
nt __in __bits(16) mas[5];
int __out __bits(16) srd;

void main() {
int min_mas = mas[0];
int max_mas = mas[0];

for (int i = 1; i < 5; i++) {
if (mas[i] < min_mas) {
min_mas = mas[i];
}
if (mas[i] > max_mas) {
max_mas = mas[i];
}
}

srd = (min_mas + max_mas) / 2;
}


------------------------------------------------------------
---------------------
int mas[5];

int __out __bits(8) srd;

int __bits(8) max = 0;
int __bits(8) min = 1000000;

void main() {
for(int i = 0; i < 5; i++){
if(min > mas[i])
min = mas[i];

if(max < mas[i])
max = mas[i];
}

srd = (max + min) / 2;
}


------------------------------------------------------------
---------------------
int __bits(8) x[10];
int __out __bits(8) res;

void main()
{
int sump=0;
int sumn=0;
int i;
for (i=0;i<10;i++)
if (x[i]>0) sump+=x[i];
else if (x[i]<0) sumn-=x[i];
while (sump>sumn) sump-=sumn;
}


------------------------------------------------------------
---------------------
int __in __bits(8) a1;
int __in __bits(8) a2;
int __in __bits(8) a3;
int __in __bits(8) a4;
int __in __bits(8) a5;
int __out __bits(8) srd;

void main() {
int __bits(16) mn = a1;
int __bits(16) mx = a1;

if (a2 < mn) mn = a2;
if (a2 > mx) mx = a2;

if (a3 < mn) mn = a3;
if (a3 > mx) mx = a3;

if (a4 < mn) mn = a4;
if (a4 > mx) mx = a4;

if (a5 < mn) mn = a5;
if (a5 > mx) mx = a5;

int __bits(16) sum = mn + mx;
srd = sum >> 1;
}


------------------------------------------------------------
---------------------
int mas[8];

int __out __bits(16) RES;

void main()
{
int __bits(16) min = mas[0];
int __bits(16) max = mas[0];
for (int i = 1; i < 5; i++)
{
if (mas[i] < min) {
min = mas[i];
}
if (mas[i] > max) {
max = mas[i];
}
} RES = (min + max) / 2;
}


------------------------------------------------------------
---------------------
int mas[8];

int __out __bits(16) RES;

void main()
{
int __bits(16) min = mas[0];
int __bits(16) max = mas[0];
for (int i = 1; i < 5; i++)
{
if (mas[i] < min) {
min = mas[i];
}
if (mas[i] > max) {
max = mas[i];
}
} RES = (min + max) / 2;
}


------------------------------------------------------------
---------------------
int VEC[128];

int __out __bits(16) RES;

void main()
{
int __bits(16) min = VEC[0];
int __bits(16) max = VEC[0];
for (int i = 1; i < 5; i++)
{
if (VEC[i] < min) {
min = VEC[i];
}
if (VEC[i] > max) {
max = VEC[i];
}
} RES = (min + max) / 2;
}


------------------------------------------------------------
---------------------
int mas[5];
unsigned __out __bits(8) srd;

void main() {
int __bits(8) min = mas[0];
int __bits(8) max = mas[0];
for (int i = 0; i<5; i++){
if (mas[i]<min){
min = mas[i];
}
}

for (int j = 0 ; j<5; j++){
if (mas[j]>max){
max = mas[j];
}
}
srd = (min+max)/2;
}


------------------------------------------------------------
---------------------
int __bits(8) x[10];
int __out __bits(8) res;

void main()
{
int sump=0;
int sumn=0;
int i;
for (i=0;i<10;i++)
if (x[i]>0) sump+=x[i];
else if (x[i]<0) sumn-=x[i];
res=sump%sumn;
}



